Identification of software configuration data

ABSTRACT

Identification of software configuration data. One or more binary files from a memory area in a computing device are identified. The binary files include information relating to execution of software. One or more strings from the identified binary files are extracted according to a rule. The rule defines requirements associated with the configuration data. A list of strings is generated from those extracted one or more strings, each of the strings in the generated list refers to configuration data in the memory area. The configuration data may be transferred to another machine, backed up, or used for informational purposes.

BACKGROUND

Computing devices, such as a computer, usually include software to provide a variety of functions to a user. For example, the computing device may include software such as an operating system or application programs that assist users in composing or editing an electronic document, importing digital photos or audio recordings from an external device (e.g., an MP3 player), browsing media content on a network (e.g., the Internet), and/or playing games.

With new or more advanced technologies becoming available everyday, the user may wish to replace an old computing device with a new computing device. While the new computing device may already include software, the user frequently wishes to move the software in the existing computing device to the new computing device without the hassle of installing programs on the new computing device. For example, suppose the user wishes to move video game programs from the existing computing device to the new computing device. While a clean or new installation of the video game program on the new computing device still enables the user to operate the video games on the new computing device, some configurable data (e.g., highest scorer or longest football game passing yards) in the existing computing device is not included in the clean or new installation of the games on the new computing device. This deficiency frustrates the user and further adversely affects the user experience on the new computing device.

Also, many people find it hard to replace an old computing device with a new one, because they may have misplaced installation CDs for their software programs, or have deleted the original install packages for downloaded programs. Many programs keep their binary data and settings spread throughout the system across various data stores (i.e. memory areas), which makes it very impractical for a user to attempt to transfer programs manually. For example, some large application programs install over 30,000 unique registry entries as part of the program. Trying to locate and move these entries manually is almost impossible.

Current migration systems enable the user to migrate settings or files from one computing device to another computing device, using static knowledge built into the migration system. Before migrating a program's settings, these migration systems are “hard coded” to identify and migrate a program and/or its settings through experimentation with an existing program. For example, to migrate a particular application's settings, a migration developer first installs it, modifies its settings, and uses a special tool to understand what effect the settings modification had on the system. This knowledge is then converted into a “script” or “hard coded” knowledge, which the migration system can use to migrate applications and/or their settings when it sees the same exact program on a source computer.

Another approach when moving programs and settings is to attempt to move “everything at once”, and hope it works on the destination system. The problem with this approach is that because it is not a componentized approach, it will often fail if there are any existing applications on the destination machine. For example, if one were to try and move all programs from the source machine, and apply it to a machine which already had a new version of some of the programs, this approach would produce a disastrous result, because it would overwrite newer versions of files with older ones.

Other systems performing migration of application programs require installing a monitoring or tracking program to monitor or track any application program installed after the monitoring program is installed. If any existing application programs were installed before the monitoring program is installed, these systems would not be able to allow users to perform an effective migration of these existing application programs.

SUMMARY

Embodiments of the invention dynamically identify data on a system which constitute one particular program. This typically occurs by using something reliable, such as a program's “install log” (which many programs keep on the system to aid with uninstall) as a starting point for fully describing the program. Then, using various algorithms and heuristics, each of which is generally targeted to a specific data store or area of the system, and this starting data is “enhanced” by making deductions on the starting data. Finally, in rare cases, where the deduced data does not adequately describe the program, it is further enhanced with expert knowledge to supplement the deduced data.

In one aspect of the invention, the identified data for a particular program may be applied to a new computing device, which, in effect, copies the program from the old computing device to the new one. Alternatively, special rules for applying the data may come into effect, such as renaming data before applying it, or not applying the program data at all due to a conflict on the destination system.

This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.

Other features will be in part apparent and in part pointed out hereinafter.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1A is a block diagram illustrating an exemplary computing system including data stores according to an embodiment of the invention.

FIG. 1B is a block diagram illustrating another view of the memory area of a computing device according to an embodiment of the invention.

FIG. 1C is a block diagram illustrating a software identification system for scanning the memory area of a computing device as illustrated in FIG. 1A according to an embodiment of the invention.

FIG. 2 is a block diagram illustrating exemplary contents of an installation log according to an embodiment of the invention.

FIG. 3A is a flow chart illustrating a method for identifying program configuration data associated with software according to an embodiment of the invention.

FIG. 3B is a block diagram illustrating a tangible computer-readable medium having computer-executable components for executing the method illustrated in FIG. 3A according to an embodiment of the invention.

FIG. 4 is a block diagram illustrating an exemplary migration of software from a source computing device to a destination computing device according to an embodiment of the invention

FIG. 5 is a flow chart illustrating a method for identifying program data associated with software according to an embodiment of the invention.

FIG. 6 is a block diagram illustrating an exemplary tangible computer-readable medium on which aspects of the invention may be stored.

FIG. 7 is a block diagram illustrating one example of a suitable computing system environment in which embodiments of the invention may be implemented.

Appendix A illustrates exemplary operations for performing one or more operations of various embodiments of the invention.

Corresponding reference characters indicate corresponding parts throughout the drawings.

DETAILED DESCRIPTION

Referring first to FIG. 1A, a block diagram illustrates a computing system 100 including data stores according to an embodiment of the invention. The system 100 includes a processor 104 which manages a memory area 106 and an interface 108 for use by a user 110 to control the processor 104 or system 100. For example, system 100 may be a computer (e.g., computer 130 in FIG. 7), a computing device, a collection of two or more computers or computing devices connected by a common communication network, such as an internet or intranet. The software 102 may be an application program or suite of application programs. The processor 104 may be one processing unit or multiple processing units for executing executable instructions, codes, or routines. The interface 108 includes a user interface (UI), a display, and/or a communication interface.

The memory area 106 may be a tangible computer-readable medium, such as, system memory 134 in FIG. 7, or both volatile and non-volatile storage media. The memory area 106 stores data which may be in a file system 112-1, a configuration data store 112-2, a data store A 112-3, and a data store B 112-4. While the file system 112-1, the configuration data store 112-2, the data store A 112-3, and a data store B 112-4 are shown in distinct blocks, it is to be understood that data associated with an operating system, software, an application or the like in the file system 112-1, the configuration data store 112-2, the data store A 112-3, and a data store B 112-4 may be scattered in the memory area 106 or may be stored in clusters in the memory area 106.

For example, FIG. 1B illustrates a block diagram showing the memory area 106 includes data for software A 114-1, software B 114-2, and software C 114-3. While each software program (i.e., software A 114-1, software B 114-2, or software C 114-3) is distinct from one another (as shown by the circles surrounding each software), one or more pieces of data may be shared by software programs, as shown by the area indicated 116. In another example, data associated with software C 114-3 is not associated or share with software A 114-1 or software B 114-2.

FIG. 1C is a block diagram illustrating a software identification system 116 for scanning the memory area 106 of the system 100, as illustrated in FIG. 1A, to identify software 102 according to an embodiment of the invention. Initially, before software 102 may be suitable for operation on system 100, an installation program or installation routines are executed. For example, the installation program may be an InstallShield® application, a Microsoft® Installer (MSI) installer, a Wise® installer, a MindVision® VISE® installer, a Nullsoft® scriptable install system, a Blizzard installer, or other proprietary installation program. The installation program is responsible for unpacking a set of data such that, after unpacking, software 102 is installed and available for operation by a user 110.

After installation, data associated with software 102 may be scattered in memory area 106. As illustrated, data associated with software 102, like other types of data, may stored in the file system 112-1, the configuration data store 112-2, the data store A 112-3, or the data store B 112-4 of the memory area 106. In another example, some data associated with software 102 may be organized for the user 110 in a structured manner, such as in a directory or a folder, while other data (e.g., those related to execution of software 102) may be scattered widely in multiple locations. In addition, other configuration data associated with software 102 may be organized in a separate data store or memory area such that the configuration data is accessed only during runtime or initialization of software and is not retrievable after execution.

As such, the software identification system 116 identifies data associated with software 102 from the memory area 106 such that the user 110 may perform operations on the data representing software 102. For example, the user 110 may wish to migrate software 102 from system 100 to another system. In particular, user 110 may copy software 102 from system 100 and then integrate software 102 to another system. In one example, software 102 includes program data, such as a set of installation data 126, a set of deduced data 128, a set of known data 130, a set of configuration data 132, or other data.

In one embodiment, software identification system 116 includes a collection of algorithms 118, installer agents 120, a collection of heuristics 122, and a knowledge base 124, which will be discussed in detail in FIGS. 3A, 3B, 4, and 5.

Referring next to FIG. 2, a diagram illustrates exemplary contents of an installation log 202 according to an embodiment of the invention. For example, some of the installation programs generate an installation log which may be stored in memory area 106 after installation. The format of the installation log may also be specific to one type of the installation program. The installation log includes a set of installation data for installing software 102. In one embodiment, the installation log may store uninstallation data for uninstalling software 102.

The installation log 202 may include a number of entries for installing software 102. For example, the installation log 202 includes an entry 204 which indicates a file “F105₁₃ APP” is to be installed for a component “DATA_USA” and the file would have a file name “USAP2M.DAT” with a version of “1.5.” Similarly, an entry 206 indicates that a file “F103₁₃ AP3” is to be installed for a component “WSTASK” with a file name “BASE.HTM” having “3.000” version. Additionally, an entry 208 indicates that a file “F001A” is to be installed for a component “MI.DLL” with a file name “USACD.DLL” and a version of “102.02.” In one embodiment, installation log 202 includes other formats of organizing installation data included therein based on the types of installation programs.

Embodiments of the invention identify a set of installation data 126 sources (such as the installation log, an uninstallation log, or a main location where the software is stored) without requiring the user to select the locations where data associated with software 102 might be located. For example, processor 104 executes a set of instructions (e.g., software identification system 116) for identifying the set of installation data 126, and such identification may involve parsing, scanning, and/or searching through the installation log. In an alternative embodiment, processor 104 executes one or more components or agents (e.g., a set of computer-executable instructions or routines), and each of the one or more components or agents identifies programs installed by one type of installation program. For example, a component may be responsible for all InstallShield® installed programs while another component or agent may be responsible for Wise® installed programs. In yet another embodiment, processor 104 may execute one component or agent that may identify the set of installation data 126 regardless of the type of installation programs.

After the set of installation data is identified, a set of deduced data 128 based on the identified set of installation data 126 is deduced by the one or more algorithms or heuristics (e.g., algorithms 118, heuristics 122). For example, deduced data 128 includes data enhanced or deduced from the installation data 126, such as shortcuts, configuration data settings, Component Object Model (COM) registration, fonts, operating system services registrations, and/or start-up settings. Other deduced data such as user defined settings, user documents, or the like may be included in the deduced data 128.

For each type of deduced data (i.e., shortcuts, or the like), embodiments of the invention provide a particular set of computer-executable instructions for deducing that type of deduced data. For example, shortcuts may be organized in one location, such as the desktop or “Main Menu” of a computing device. These shortcuts link to various files on the computing device, so that user 110 can double-click to immediately access programs (e.g., software 102 in FIG. 1C) or other files in the main memory area. Given that it is known which binary files belong to each application (i.e. from the install log or starting basis—126), one can deduce that a shortcut belongs to a particular application when the shortcut's target file belongs to the particular application or software. For example, suppose software 102 is “My App.” If a shortcut called “Start Menu\Programs\My App\My App.lnk” exists, and provides a link to a target binary file “c:\program files\my app\app.exe”, and it is to be known that “c:\program files\my app\app.exe” belongs to “my app” from its installation log, it can be deduced that the shortcut “Start Menu\Programs\My App\My App.lnk” also belongs to “My App”, since it points to a file belonging to “My App”. Appendix A includes exemplary instructions illustrating an example of the collection of algorithms 118 and the collection of heuristics 122 for identifying deduced data 128 of or deducing the installation data 126 of each of the types of deduced data.

In yet another example, in identifying the Common Object Model (e.g., COM) registration data which belongs to a particular application or software, embodiments of the invention deduce all the object configuration entries which belong to software 102. In another example of identifying operating system services registration data, information associated with operating system services that may be implemented by software 102 is identified by deduction. Also, deduced data relating to start-up settings, which include values in the configuration for running the software 102 at initialization of an operating system, are deduced. In one example, each specialized area of the system (such as shortcuts, system services, COM registration, user settings, etc . . . ) may have a dedicated algorithm or heuristic to determine which pieces of data belong to software. Other examples related to fonts or other deduced data are further described in Appendix A.

Referring now to FIGS. 3A-3B, a flow chart and a block diagram illustrate a method for deducing configuration data according to an embodiment of the invention. As described above, deduced data includes, among other data or parameters, configuration data. In deducing such data, binary files in memory area 106 are identified at 302. For example, the program binary files may be stored by a storage component 316 of a tangible computer-readable medium 314, and a search component 318 identifies the program binary files that are associated with software 102. In one embodiment, the program binary files include executable files, executable library files, and executable object files. In another embodiment, the program binary files may be identified by scanning or parsing the content of the installation log or a file.

Once the program binary files are identified, at 304, strings are extracted or parsed according to a rule from each of the identified binary files. For example, a parser component 320 of the tangible computer-readable medium 314 may parse or extract strings from the identified binary files. The rule defines requirements associated with the configuration data. For example, the rule may define requirements such as a sequence (e.g., begins with “software\” or “system”) of the strings, a string length, or a terminating character (e.g., a NULL character). In one example, the strings are parameters of a function call from the software to open or create a configuration data identifier. These strings were typically inserted into a binary file by an application's compiler, in response to the function call.

At 306, it is determined whether the configuration data referred to by the extracted or parsed string exists as configuration data in memory area 106. In one example, an output component 322 of tangible computer-readable medium 314 is configured to perform the determination operation. A list is generated to include each of the strings that refers to configuration data in the data store or memory area. For example, some of the extracted or parsed strings may refer to configuration data stored in memory area 106 while other strings may refer to configuration data that is no longer present in the present in memory area 106. By doing so, embodiments of the invention validate useful and actual configuration data by identifying the configuration data that actually exists in memory area 106. In one embodiment, the configuration data is checked against both a data store storing deduced data associated with a user operating the software (e.g., HKEY_CURRENT_USER) and in another data store storing deduced data associated with the computing device where the software is installed (e.g., HKEY_LOCAL_MACHINE).

In another embodiment, at 308, a subset of configuration data is excluded from a list of strings if the subset of configuration data (e.g., known data 130) is known to belong to other system programs or software (e.g., software 102), or other software in the computing device (e.g., system 100). For example, suppose software A and software B both access configuration data X (i.e., sharing information in the configuration data X). From previously identifying configuration data associated with software A (i.e. creating the list of known data 130), it is known that configuration data X belongs to software A (such as a system program) and not software B (a user installed program). As such, if the list is used to migrate software B from computing device 1 to computing device 2 by a migration component 324, the configuration data X would not be included in the list because configuration data X belongs to software A even though both software A and B references, accesses, or shares configuration data X.

At 310, the configuration data known to be safe is included in the list of configuration data. At 312, the list of the configuration data is generated, composed, or outputted for further processing, such as the migration component 324. In one embodiment, the list includes at least the names of the configuration data and the configuration data itself.

In yet another embodiment, a system or tangible computer-readable medium includes one or more computer-executable components for executing instructions or routines described in FIG. 3A.

In one embodiment, after these components or agents collect the set of deduced data based on the identified set of installation data, the knowledge base 124 may provide patching data or additional information to the collected set of deduced data 128. For example, while the set of installation data and the set of deduced data include most of the data associated with software 102, some software includes obscure or particular data that is unique to the software. Such obscure or particular sets of data may include a certain miscellaneous configuration data identifier (e.g., registry key), for example, and the configuration data identifier is not defined anywhere in the installation log, or related to any deduced data. Embodiments of the invention can manually modify or supplement this miscellaneous configuration data identifier by creating a patch in knowledge base 124 for the software. In one embodiment, knowledge base 124 may include an online knowledge data store, a human input, or expert knowledge. As such, the knowledge base 124 supplements the set of installation data 126 and the set of deduced data 128 to completely identify data associated with software 102.

After the set of deduced data 128 is collected or, in one embodiment, the set of deduced data is patched by information from knowledge base 124, a set of program data is generated. For example, the set of program data represents, defines, or describes all data (both executable and non-executable) required for the execution or operation of software 102. For example, the set of program data includes user data such as the lowest amount of time in completing a 500-mile race in a racing game, a saved document file created with a particular spreadsheet program, or the highest number of three-pointer baskets in a basketball game. In one embodiment, the set of program data includes a list of objects which belongs to or constitutes the software 102. In another example, the set of program data includes a sequence of executing or installing software 102 in a computing device, which is illustrated below:

{   “Copy C:\Program Files\App\MyApp.exe to   C:\Programs\App\MyApp.exe”   “Copy all keys and values under HKLM\Software\MyCompany\App”   “Increment the integer value stored at registry key HKLM\   Software\X”   “Create Windows NT service Y, implemented by     C:\Programs\App\MyService.exe” }

In an alternative embodiment, a pattern representing the program data is constructed. For example, the pattern may include information such as collecting program data in the following locations: “C:\program files\my app\*”, or “HKLM\Software\OpenO\10\*”. The generated set of program data may be applied to a destination computing device. For example, the generated set of program data is applied, as part of migrating software 102, from a source computing device to a destination computing device. Also, the interface 108 may receive instructions from user 10 for migrating software 102 from one computing device to another computing device using the generated set of program data.

FIG. 4 is a block diagram illustrating an exemplary migration of software 306 from a source computing device 402 to a destination computing device 404 according to an embodiment of the invention. For example, it is known in the art that installed software generally may not simply be copied from one computing device to another computing device and be executed on the another computing device due to the different execution environments of the computing devices. Also, some prior migration systems fail to fully migrate software from a source (e.g., the source computing device 402) to a destination (e.g., the destination computing device 404) because the prior migration systems attempt to copy everything at once and do not use a componentized approach.

Initially, on the destination computing device 404, a list of software that is currently installed in destination computing device 404 is detected. Once it is determined that software 406 is not already installed in destination computing device 404, and no other problematic conditions exist (such as different versions of the same software, incompatible software, or other issues) software 406 is migrated from the source computing device 402 to destination computing device 404.

In one embodiment, an implementation component 610 (see FIG. 6) applies/migrates software 406, which is represented by program data of software 406. In one embodiment, implementation component 610 is installed in source computing device 402 and not in destination computing device 404. In another embodiment, implementation component 610 detects a lower version or newer version of software 406 before applying software 406. In yet another alternative embodiment, implementation component 610 modifies the software by modifying the set of installation data, the set of deduced data and the set of program data as a function of a set of modifying data 408. In one example, the implementation component 610 applies the software 406 by selectively updating software 406, as needed, after migrating software 406 to destination computing device 404 with updating data coupled to destination computing device 404 via wired or wireless means. Alternatively, these updates simulate what the application's or software's installer would have done had it installed the application or software itself. In yet another alternative embodiment, the updates simply make it possible to run the software such as to resolve file version conflicts. Alternatively, backing up the software on the source computing device, uninstalling the software from the source computing device, and/or providing information relating to the software may be part of an embodiment of the invention.

FIG. 5 is a flow diagram illustrating a method of identifying data associated with software. At 502, an identification component 604 in FIG. 6 identifies a set of installation data from an installation log. At 504, one or more data components 606 collect a set of deduced data based on the identified set of installation data. In one example, the deduced data defines data relating to the software. An object component 608 generates or organizes a set of program data as a function of the collected set of deduced data at 506. The set of program data represents operations performed for the operation of the software. At 508, alternatively, the set of deduced data is patched by a knowledge base for supplementing the collected set of deduced data. The set of program data is employed as a function of the organized set of program data. For example, at 510, a conflict component 614 determines whether the set of program data creates a conflict with data on a destination computing device when the set of program data is applied to the destination computing device. If the determination is negative, an implementation component 610 applies the software as a function of the generated set of program data at 512. In another alternative embodiment, the software is migrated by the implementation component 610 from a source computing device to the destination computing device and storing the set of installation data, the set of deduced data and the set of program data in the destination computing device at 512. In yet another alternative embodiment, if the conflict component 614 determines that there is a conflict at 510, the set of program data is not applied or migrated to the destination computing device at 514. In such an embodiment, the user 110 may be notified if the set of program data is not applied or migrated to the destination computing device.

FIG. 7 shows one example of a general purpose computing device in the form of a computer 130. In one embodiment of the invention, a computer such as the computer 130 is suitable for use in the other figures illustrated and described herein. Computer 130 has one or more processors or processing units 132 and a system memory 134. In the illustrated embodiment, a system bus 136 couples various system components including the system memory 134 to the processors 132. The bus 136 represents one or more of any of several types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, and a processor or local bus using any of a variety of bus architectures. By way of example, and not limitation, such architectures include Industry Standard Architecture (ISA) bus, Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, Video Electronics Standards Association (VESA) local bus, and Peripheral Component Interconnect (PCI) bus also known as Mezzanine bus.

The computer 130 typically has at least some form of computer readable media. Computer readable media, which include both volatile and nonvolatile media, removable and non-removable media, may be any available medium that may be accessed by computer 130. By way of example and not limitation, computer readable media comprise computer storage media and communication media. Computer storage media include volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. For example, computer storage media include RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical disk storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium that may be used to store the desired information and that may be accessed by computer 130. Communication media typically embody computer readable instructions, data structures, program modules, or other data in a modulated data signal such as a carrier wave or other transport mechanism and include any information delivery media. Those skilled in the art are familiar with the modulated data signal, which has one or more of its characteristics set or changed in such a manner as to encode information in the signal. Wired media, such as a wired network or direct-wired connection, and wireless media, such as acoustic, RF, infrared, and other wireless media, are examples of communication media. Combinations of any of the above are also included within the scope of computer readable media.

The system memory 134 includes computer storage media in the form of removable and/or non-removable, volatile and/or nonvolatile memory. In the illustrated embodiment, system memory 134 includes read only memory (ROM) 138 and random access memory (RAM) 140. A basic input/output system 142 (BIOS), containing the basic routines that help to transfer information between elements within computer 130, such as during start-up, is typically stored in ROM 138. RAM 140 typically contains data and/or program modules that are immediately accessible to and/or presently being operated on by processing unit 132. By way of example, and not limitation, FIG. 7 illustrates operating system 144, application programs 146, other program modules 148, and program data 150.

The computer 130 may also include other removable/non-removable, volatile/nonvolatile computer storage media. For example, FIG. 7 illustrates a hard disk drive 154 that reads from or writes to non-removable, nonvolatile magnetic media. FIG. 7 also shows a magnetic disk drive 156 that reads from or writes to a removable, nonvolatile magnetic disk 158, and an optical disk drive 160 that reads from or writes to a removable, nonvolatile optical disk 162 such as a CD-ROM or other optical media. Other removable/non-removable, volatile/nonvolatile computer storage media that may be used in the exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, digital versatile disks, digital video tape, solid state RAM, solid state ROM, and the like. The hard disk drive 154, and magnetic disk drive 156 and optical disk drive 160 are typically connected to the system bus 136 by a non-volatile memory interface, such as interface 166.

Examples of well known computing systems, environments, and/or configurations that may be suitable for use with aspects of the invention include, but are not limited to, personal computers, server computers, hand-held or laptop devices, multiprocessor systems, microprocessor-based systems, set top boxes, programmable consumer electronics, mobile telephones, network PCs, minicomputers, mainframe computers, distributed computing environments that include any of the above systems or devices, and the like.

Embodiments of the invention may be described in the general context of computer-executable instructions, such as program modules, executed by one or more computers or other devices. Generally, program modules include, but are not limited to, routines, programs, objects, components, and data structures that perform particular tasks or implement particular abstract data types. Aspects of the invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

A user may enter commands and information into computer 130 through input devices or user interface selection devices such as a keyboard 180 and a pointing device 182 (e.g., a mouse, trackball, pen, or touch pad). Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, or the like. These and other input devices are connected to processing unit 132 through a user input interface 184 that is coupled to system bus 136, but may be connected by other interface and bus structures, such as a parallel port, game port, or a Universal Serial Bus (USB). A monitor 188 or other type of display device is also connected to system bus 136 via an interface, such as a video interface 190. In addition to the monitor 188, computers often include other peripheral output devices (not shown) such as a printer and speakers, which may be connected through an output peripheral interface (not shown).

In operation, computer 130 executes computer-executable instructions such as those illustrated in the figures to implement aspects of the invention.

The order of execution or performance of the operations in embodiments of the invention illustrated and described herein is not essential, unless otherwise specified. That is, the operations may be performed in any order, unless otherwise specified, and embodiments of the invention may include additional or fewer operations than those disclosed herein. For example, it is contemplated that executing or performing a particular operation before, contemporaneously with, or after another operation is within the scope of aspects of the invention.

Embodiments of the invention may be implemented with computer-executable instructions. The computer-executable instructions may be organized into one or more computer-executable components or modules. Aspects of the invention may be implemented with any number and organization of such components or modules. For example, aspects of the invention are not limited to the specific computer-executable instructions or the specific components or modules illustrated in the figures and described herein. Other embodiments of the invention may include different computer-executable instructions or components having more or less functionality than illustrated and described herein.

When introducing elements of the present invention or the embodiment(s) thereof, the articles “a,” “an,” “the,” and “said” are intended to mean that there are one or more of the elements. The terms “comprising,” “including,” and “having” are intended to be inclusive and mean that there may be additional elements other than the listed elements.

As various changes could be made in the above constructions, products, and methods without departing from the scope of aspects of the invention, it is intended that all matter contained in the above description and shown in the accompanying drawings shall be interpreted as illustrative and not in a limiting sense.

Appendix A

The following illustrates exemplary operations in deducing the installation data:

Section I: Shortcuts

{  For a set of files X,     scan all well established locations for storing shortcuts (start   menu, desktop, quicklaunch),     and     return the set of all .lnk files which point to files in X. }

Section II: Configuration Data settings:

{  For a set of executable files Y,     scan each such binary file for strings beginning with “Software\”     or “System\”, and ending in NULL;     {  For each strings having ANSI and UNICODE strings;         set the returned results = set S.     } {  For each string in set S,     identify if the string exists as a configuration data identifier,     either in “HKEY_LOCAL_MACHINE” or     “HKEY_CURRENT_USER”.   If strings in set S exists as a configuration data identifier,   then     check it against a filter of allowable areas of the configuration   data (i.e. non system areas).     If strings occur in an allowable area of the configuration data   (e.g., according to manually developed filters),     then       identify the configuration data identifier S as a setting for     the application or software (for migration). }

Section III: Object (e.g., COM) Registration

{  Given a set of program data (files, registry entries, etc . . . ) Z belonging to software:   For all entries in HKEY_CLASSES_ROOT,   collect: all CLSID keys which have implementing files in Z;   all TypeLib keys which have implementing files in Z;   all Interface keys which have implementing CLSID keys in Z;   all Interface keys which have implementing TypeLib keys in Z;   all AppID GUID keys which have implementing CLSID keys in Z;   all AppID keys which have implementing AppID GUID keys in Z;   all FileType keys which have implementing CLSID keys in Z;   all ProgID keys which have implementing CLSID keys in Z;   all ProgID Default Icon entries which have implementing files in Z;   all Shell commands (and also parent ProgIDs) which have   implementing files in Z;   all ShellEx entries which have implementing CLSID keys in Z;   all Extension keys which have implementing ProgIDs in Z;   all Extension “Open With” keys (e.g. “HKEY_CLASSES_ROOT\.zip\OpenWithProgids\<progid>”) which have implementing ProgID keys in Z;   all Extension ShellEx keys (e.g. “HKEY_CLASSES_ROOT\.zip\ShellEx\<guid>”) which have implementing CLSID keys in Z;   all Mime Content Types which have implementing Extension keys   in Z.   If the COM registration entry is deemed to belong to the system (e.g. a CLSID which is implemented by a known system file or system registry entry),   then     remove the entry from the set of deduced data. }

Section IV: Font Registration

{   Given a set of files X,   collect all entries in HKLM\SOFTWARE\CurrentVersion\Fonts,   which point to files in X. }

Section V: Operating System Services

{  Given a set of files X,   For each service in the Service Control Manager (SCM),   collect deduced data associated with each service that has implementing files in the set X;   collect deduced data in which each service is implemented by a dynamic link library (DLL);   collect deduced data in which each service is hosted in another process (e.g., svchost.exe). }

In the alternative embodiment where migration is used:

{ For collected deduced data related to services described above,   migrate the collected deduced data using the SCM API. }

Section VI: Environment Variables

{  Given a set of binary files X belonging to an application or software:   For all entries in HKLM\SYSTEM\CurrentControlSet\Control\ Session Manager\Environment and HKEY_CURRENT_USER\ Environment;   collect entries that have values which contain paths in the set X.   For “%PATH% environment variables, collect entries whose semicolon separated values contain paths in the set X. }

Section VII: Start-up Settings

{  Given a set of binary files X belonging to an application or software:   collect all entries in HKLM\SOFTWARE\CurrentVersion\Run   and HKCU\SOFTWARE\CurrentVersion\Run which point   to files in the set X. }

Section VIII: Shared DLLs

{  Given a set of binary files X belonging to software:   For all entries in HKLM\SOFTWARE\System\CurrentVersion\ SharedDlls, which point to files in the set X,   collect the set of deduced data by placing a new entry with reference count 1 on the destination computing device (if it doesn't already exist on the target machine),   or simply incrementing the reference count on the target computing device if the value already exists. } 

1. A method implemented at least in part by a computing device for identifying configuration data associated with software, said configuration data being stored in a memory area, said method executed by a processor of the computing device, said method comprising: identifying binary files belonging to the software from the memory area in the computing device, said binary files comprising one or more executable files, said binary files being identified either from an installation log created when the software was installed or from an uninstallation log created when the software was installed; extracting strings from the identified binary files according to a rule, said rule defining requirements associated with the configuration data, said requirements comprising: a sequence of said extracted strings; a string length of said extracted strings; and a terminating character of said extracted strings, said extracted strings identifying configuration data and being inserted into the binary files by a compiler of the software in response to a function call of the software; deducing a set of one or more types of deduced data from the extracted strings by comparing data referenced by the extracted strings with the stored configuration data of the software to determine whether the extracted text strings exist in the memory area; generating a list of strings from the deduced set of one or more types of deduced data, each of the strings in the generated list of strings referring to configuration data in the memory area, said configuration data in said memory area including data associated with an environment to operate the software and including data associated with the computing device where the software is installed; and employing the configuration data identified by each of the strings in the generated list of strings.
 2. The method of claim 1, further comprising filtering the generated list by removing a subset of strings from the list which are associated with a system software of the computing device.
 3. The method of claim 1, wherein identifying comprises identifying the binary files from the memory area or identifying the binary files from a file, and wherein extracting comprises extracting strings from the identified binary files.
 4. The method of claim 1, wherein the generated list includes one of the following: the names of the configuration data and the configuration data itself.
 5. The method of claim 1, wherein the binary files further include executable library files and executable object files.
 6. The method of claim 1, wherein the generated list of strings do not refer to data that does not exist in the data store.
 7. The method of claim 1, wherein employing comprises one or more of the following: migrating the configuration data, removing the configuration data, backing up the configuration data, identifying the configuration data, or repackaging the configuration data.
 8. The method of claim 1, wherein one or more tangible computer-readable media have computer-executable instructions for performing the method of claim
 1. 9. A system for identifying configuration data associated with software, said system comprising: a data store for storing binary files, software, a rule, and configuration data associated with software; a processor executing computer-executable instructions for: identifying binary files of the software from the data store in a computing device, said binary files comprising one or more executable files; extracting strings from the identified binary files according to the rule, said rule defining requirements associated with the configuration data, said requirements comprising one or more of: a sequence of said extracted strings; a string length of said extracted strings; and a terminating character of said extracted strings, said extracted strings being inserted into the binary files by a compiler of the software in response to a function call of the software; deducing a set of one or more types of deduced data from the extracted strings by comparing data referenced by the extracted strings with the stored configuration data of the software to determine whether the extracted text strings exist in the memory area; generating a list of strings from the deduced set of one or more types of deduced data, each of the strings in the generated list of strings referring to configuration data in the data store, the list of strings not including the extracted strings which do not refer to configuration data in the data store, said configuration data in said data store including data associated with an environment to operate the software and including data associated with the computing device where the software is installed; and employing the configuration data identified by each of the strings in the generated list of strings.
 10. The system of claim 9, further comprising means for filtering the generated list by removing a set of configuration data from the list which are associated with a system software.
 11. The system of claim 9, wherein processor is configured to identify the binary files from a file, and wherein the processor is configured to extract strings from the identified binary files.
 12. The system of claim 9, wherein the processor is further configured to perform at least one of the following operations: migrating the configuration data, removing the configuration data, backing up the configuration data, identifying the configuration data, or repackaging the configuration data.
 13. One or more tangible computer-readable storage media having computer-executable components for identifying configuration data associated with software, said computer-executable components comprising: a storage component for storing binary files, software, a rule, and configuration data associated with software wherein the configuration data is checked against both a data store storing deduced data associated with a user operating the software and in a data store storing deduced data associated with the computing device where the software is installed; a search component for identifying binary files of the software from the data store in a computing device, said binary files including information relating to execution of the software and comprising one or more executable files; a parser component for parsing strings from the identified binary files according to the rule, said parsed strings being inserted into the binary files by a compiler of the software in response to a function call of the software, said rule defining requirements associated with the configuration data, said requirements comprising a sequence of said parsed strings; a string length of said parsed strings; and a terminating character of said parsed strings; one or more data components for deducing a set of one or more types of deduced data from the parsed strings by comparing data referenced by the parsed strings with the stored configuration data of the software to determine whether the parsed text strings exist in the storage component; and an output component for composing a list of strings from the deduced set of one or more types of deduced data, each of the strings in the composed list of strings referring to configuration data in the data store.
 14. The tangible computer-readable storage media of claim 13, wherein the output component further comprising removing a set of strings from the composed list if the configuration data referred by the set of strings is accessed by the software and other software in the computing device.
 15. The tangible computer-readable storage media of claim 13, wherein the parser component parses strings from the identified binary files, and wherein the composed list includes one or more of the following: the names of the configuration data and the configuration data itself.
 16. The tangible computer-readable storage media of claim 13, wherein the binary files further include executable library files and executable object files, and wherein the list of strings does not include the parsed strings which do not refer to configuration data in the data store.
 17. The tangible computer-readable storage media of claim 13, wherein the output component composes the list of strings refer to configuration data in the data store, said data store storing data associated with an environment to operate the software and in a data store storing data associated with the computing device where the software is installed.
 18. The tangible computer-readable storage media of claim 13, further comprising a migration component for migrating the configuration data of the software as a function of the composed list and other data associated with the software. 